//#include<iostream>
//using namespace std;
//namespace bit
//{
//	template<typename T>
//	struct ListNode
//	{
//		T val;
//		struct ListNode* pre;
//		struct ListNode* next;
//		ListNode(const T& x = T())
//			:pre(nullptr), next(nullptr), val(x)
//		{}
//	};
//	template<class T,class Ref,class Ptr>
//	struct IteratorNode
//	{
//		typedef ListNode<T> node;
//		typedef IteratorNode<T, Ref, Ptr> self;//T T& T*
//		node* _node;
//		IteratorNode(node* n)
//			:_node(n)
//		{}
//		//*T
//		T operator*()
//		{
//			return _node->val;
//		}
//		//T->
//		Ptr operator->()
//		{
//			return &_node->val;
//		}
//		//T++;
//		self& operator++()
//		{
//			_node = _node->next;
//			return *this;
//		}
//		//++T
//		self operator++(int)
//		{
//			IteratorNode tmp(*this);
//			_node = _node->next;
//			return tmp;
//		}
//		//--T
//		self& operator--()
//		{
//			_node = _node->_prev;
//			return *this;
//		}
//		//T--
//		self operator--(int)
//		{
//			self tmp(*this);
//			_node = _node->_prev;
//
//			return tmp;
//		}
//		bool operator!=(const self& it)
//		{
//			return _node != it._node;
//		}
//
//		bool operator==(const self& it)
//		{
//			return _node == it._node;
//		}
//	};
//	template<typename T>
//	struct list
//	{
//		typedef ListNode<T> node;
//		typedef IteratorNode<T,T*,T&> iterator;
//		typedef IteratorNode<T,const T*,const T&> const_iterator;
//	private:
//		node* head;
//		size_t size;
//	public:
//		void init()
//		{
//			head = new node;
//			head->next = head;
//			head->pre = head;
//			size = 0;
//		}
//		list()
//		{
//			init();
//		}
//		list(const list<T>& lt)
//		{
//			init();
//			iterator t = lt.head->next;
//			while (t != lt.head)
//			{
//				push_back(t._node->val);
//				t._node = t._node->next;
//			}
//		}
//		iterator begin()
//		{
//			return head->next;
//		}
//		iterator end()
//		{
//			return head;
//		}
//		const_iterator cbegin() const
//		{
//			return head->next;
//		}
//		const_iterator cend() const
//		{
//			return head;
//		}
//		void push_back(const T& val)
//		{
//			insert(end(), val);
//		}
//		void push_front(const T& x)
//		{
//			insert(begin(), x);
//		}
//		void pop_front()
//		{
//			erase(begin());
//		}
//		void pop_back()
//		{
//			erase(end()->pre);
//		}
//		void insert(iterator pos, const T& val)
//		{
//			node* newn = new node;
//			newn->val = val;
//			newn->pre = pos._node->pre;
//			pos._node->pre->next = newn;
//			newn->next = pos._node;
//			pos._node->pre = newn;
//			size++;
//		}
//		iterator erase(iterator t)
//		{
//			iterator pos = t._node->next;
//			t._node->pre->next = t._node->next;
//			t._node->next->pre = t._node->pre;
//			delete []t._node;
//			size--;
//			return pos;
//		}
//		void clear()
//		{
//			iterator t = begin();
//			while (t != end())
//			{
//				t=erase(t);
//			}
//		}
//		void swap(list<T>& lt)
//		{
//			std::swap(head, lt.head);
//			std::swap(size, lt.size);
//		}
//		list<T>& operator=(list<T> lt)
//		{
//			swap(lt);
//			return *this;
//		}
//		~list()
//		{
//			clear();
//			delete[] head;
//			head = nullptr;
//		}
//		size_t _size() const
//		{
//			return size;
//		}
//
//		bool empty()
//		{
//			return size == 0;
//		}
//	};
//	
//}
//int main()
//{
//	bit::list<int> l;
//	bit::list<int> l2;
//	l.push_back(1);
//	l.push_back(2);
//	l.push_back(3);
//	l.push_back(4);
//	l2.push_back(4);
//	l2.push_back(4);
//	l2.push_back(4);
//	l.erase(l.begin());
//	l.insert(l.begin(),5);
//	l = l2;
//	bit::list<int>::const_iterator t = l.cbegin();
//	
//	while (t != l.cend())
//	{
//		cout << *t << ' ';
//		t ++;
//	}
//}
#include<iostream>
#include<stack>
using namespace std;
class MinStack {
public:
    std::stack<int> s1;
    std::stack<int> s2;
    MinStack() {

    }

    void push(int val) {
        s1.push(val);
        if (s2.size() == 0)
        {
            s2.push(val);
        }
        else if (s2.top() >= val)
        {
            s2.push(val);
        }
    }

    void pop() {
        while (!s1.empty())
        {
            if (s1.top() == s2.top())
            {
                s2.pop();
            }
            s1.pop();
        }
    }

    int top() {
        return s1.top();
    }

    int getMin() {
        return s2.top();
    }
};
int main()
{
    MinStack s;
    s.push(-1);
    s.push(0);
    s.push(-3);
    cout << s.getMin();
    s.pop();
    cout << s.top();
    //cout<<s.getMin();
}
